package com.yjj.springboot3.ai.config;

import cn.hutool.json.JSONUtil;
import com.yjj.springboot3.service.ConversationService;
import com.yjj.springboot3.model.entity.Conversation;
import com.yjj.springboot3.model.json.ChatMessage;
import com.yjj.springboot3.model.json.ChatMessageList;
import org.springframework.ai.chat.memory.ChatMemory;

import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

@Component
public class MyChatMemory implements ChatMemory {

    @Autowired
    private ConversationService conversationService;
    
    @Autowired
    private ChatProperties chatProperties;

    // 内存缓存，提高性能
    private final ConcurrentHashMap<String, List<Message>> memoryCache = new ConcurrentHashMap<>();
    

    
    @Override
    public void add(String conversationId, Message message) {
        // 从数据库加载所有消息（不限制数量）
        List<Message> allMessages = loadFromDatabase(conversationId);
        if (allMessages == null) {
            allMessages = new ArrayList<>();
        }
        
        // 添加新消息
        allMessages.add(message);
        
        // 更新缓存（保存所有消息）
        memoryCache.put(conversationId, allMessages);
        
        // 持久化到数据库（保存所有消息）
        persistToDatabase(conversationId, allMessages);
    }

    @Override
    public void add(String conversationId, List<Message> messages) {
        if (messages == null || messages.isEmpty()) {
            return;
        }
        
        // 从数据库加载所有消息（不限制数量）
        List<Message> allMessages = loadFromDatabase(conversationId);
        if (allMessages == null) {
            allMessages = new ArrayList<>();
        }
        
        // 添加新消息
        allMessages.addAll(messages);
        
        // 更新缓存（保存所有消息）
        memoryCache.put(conversationId, allMessages);
        
        // 持久化到数据库（保存所有消息）
        persistToDatabase(conversationId, allMessages);
    }

    @Override
    public List<Message> get(String conversationId) {
        System.out.println("=== 获取消息 ===");
        System.out.println("请求的conversationId: " + conversationId);
        
        // 获取所有消息
        List<Message> allMessages = getAllMessages(conversationId);
        
        // 应用消息数量限制（只影响返回给AI的消息，不影响数据库存储）
        List<Message> limitedMessages = limitMessages(allMessages);
        
        System.out.println("数据库中总消息数: " + allMessages.size() + ", 返回给AI的消息数: " + limitedMessages.size());
        
        return limitedMessages;
    }

    
    /**
     * 获取所有消息（不限制数量）
     */
    private List<Message> getAllMessages(String conversationId) {
        // 先从缓存中获取
        List<Message> cachedMessages = memoryCache.get(conversationId);
        System.out.println("缓存中的消息数量: " + (cachedMessages != null ? cachedMessages.size() : 0));
        
        if (cachedMessages != null) {
            System.out.println("从缓存返回所有消息");
            return new ArrayList<>(cachedMessages);
        }
        
        // 从数据库中获取
        System.out.println("缓存中没有，从数据库加载...");
        List<Message> messages = loadFromDatabase(conversationId);
        
        // 更新缓存
        if (messages != null && !messages.isEmpty()) {
            System.out.println("加载到 " + messages.size() + " 条消息，更新缓存");
            memoryCache.put(conversationId, messages);
        } else {
            System.out.println("数据库中没有找到消息");
        }
        
        return messages != null ? messages : new ArrayList<>();
    }

    @Override
    public void clear(String conversationId) {
        // 只清除缓存，保留数据库数据以维持持久化的意义
        memoryCache.remove(conversationId);
    }

    /**
     * 持久化消息到数据库
     */
    private void persistToDatabase(String conversationId, List<Message> messages) {
        try {
            // 将Message对象转换为ChatMessage实体类
            List<ChatMessage> chatMessages = new ArrayList<>();
            for (Message message : messages) {
                String type;
                if (message instanceof UserMessage) {
                    type = "USER";
                } else if (message instanceof AssistantMessage) {
                    type = "ASSISTANT";
                } else {
                    type = "UNKNOWN";
                }
                
                ChatMessage chatMessage = new ChatMessage(
                    message.getText(),
                    type,
                    message.getMessageType().name()
                );
                chatMessages.add(chatMessage);
            }
            
            // 创建消息列表包装对象
            ChatMessageList messageList = new ChatMessageList(chatMessages);
            messageList.setTotalCount(chatMessages.size());
            messageList.setTimestamp(System.currentTimeMillis());
            String messageJson = JSONUtil.toJsonStr(messageList);
            Long id = convertToLong(conversationId);
            
            System.out.println("=== 持久化到数据库 ===");
            System.out.println("conversationId: " + conversationId);
            System.out.println("转换后的Long ID: " + id);
            System.out.println("消息数量: " + (messages != null ? messages.size() : 0));
            System.out.println("JSON内容: " + messageJson);
            
            if (id != null) {
                boolean result = conversationService.saveOrUpdateConversation(id, messageJson);
                System.out.println("数据库保存结果: " + result);
            } else {
                System.out.println("ID转换失败，跳过数据库保存");
            }
        } catch (Exception e) {
            System.err.println("持久化失败: " + e.getMessage());
            e.printStackTrace();
            // 记录日志，但不影响主流程
        }
    }

    /**
     * 从数据库加载消息
     */
    private List<Message> loadFromDatabase(String conversationId) {
        try {
            Long id = convertToLong(conversationId);
            
            System.out.println("=== 从数据库加载消息 ===");
            System.out.println("conversationId: " + conversationId);
            System.out.println("转换后的Long ID: " + id);
            
            if (id != null) {
                Conversation conversation = conversationService.getById(id);
                
                System.out.println("查找到的对话记录: " + (conversation != null));
                if (conversation != null) {
                    System.out.println("对话状态: " + conversation.getStatus());
                    System.out.println("消息内容: " + conversation.getMessage());
                    System.out.println("消息内容是否为空: " + !StringUtils.hasText(conversation.getMessage()));
                }
                
                if (conversation != null && StringUtils.hasText(conversation.getMessage())) {
                    List<Message> messages = new ArrayList<>();
                    
                    try {
                        // 尝试新的实体类格式解析
                        ChatMessageList messageList = JSONUtil.toBean(conversation.getMessage(), ChatMessageList.class);
                        
                        for (ChatMessage chatMessage : messageList.getMessages()) {
                            String content = chatMessage.getContent();
                            String type = chatMessage.getType();
                            
                            if ("USER".equals(type)) {
                                messages.add(new UserMessage(content));
                            } else if ("ASSISTANT".equals(type)) {
                                messages.add(new AssistantMessage(content));
                            }
                        }
                        
                        System.out.println("使用新格式成功解析消息: " + messages.size() + " 条");
                        
                    } catch (Exception e) {
                        System.out.println("新格式解析失败，尝试兼容旧格式: " + e.getMessage());
                        
                        // 兼容旧格式：List<Map<String, Object>>
                        try {
                            List<Object> rawList = JSONUtil.toList(conversation.getMessage(), Object.class);
                            
                            for (Object item : rawList) {
                                if (item instanceof java.util.Map) {
                                    @SuppressWarnings("unchecked")
                                    java.util.Map<String, Object> messageMap = (java.util.Map<String, Object>) item;
                                    
                                    String content = (String) messageMap.get("content");
                                    String type = (String) messageMap.get("type");
                                    
                                    if ("USER".equals(type)) {
                                        messages.add(new UserMessage(content));
                                    } else if ("ASSISTANT".equals(type)) {
                                        messages.add(new AssistantMessage(content));
                                    }
                                }
                            }
                            
                            System.out.println("使用旧格式兼容解析成功: " + messages.size() + " 条");
                            
                        } catch (Exception ex) {
                            System.err.println("旧格式兼容解析也失败: " + ex.getMessage());
                            ex.printStackTrace();
                        }
                    }
                    
                    System.out.println("成功加载消息数量: " + messages.size());
                    return messages;
                }
            }
        } catch (Exception e) {
            System.err.println("从数据库加载消息失败: " + e.getMessage());
            e.printStackTrace();
            // 记录日志，但不影响主流程
        }
        
        System.out.println("返回空的消息列表");
        return new ArrayList<>();
    }

    /**
     * 将String类型的conversationId转换为Long类型
     */
    private Long convertToLong(String conversationId) {
        if (!StringUtils.hasText(conversationId)) {
            return null;
        }
        
        try {
            return Long.valueOf(conversationId);
        } catch (NumberFormatException e) {
            // 如果转换失败，记录日志但不抛出异常
            System.err.println("无法将conversationId转换为Long类型: " + conversationId);
            return null;
        }
    }

    /**
     * 限制消息数量，保留最新的N条消息（使用配置中的默认值）
     * @param messages 原始消息列表
     * @return 限制后的消息列表
     */
    private List<Message> limitMessages(List<Message> messages) {
        if (messages == null || messages.isEmpty()) {
            return messages;
        }
        
        // 如果未启用消息限制，直接返回原列表
        if (!chatProperties.isEnableMessageLimit()) {
            System.out.println("消息数量限制已禁用，返回所有消息");
            return messages;
        }
        
        // 使用配置中的默认值
        int maxMessages = chatProperties.getMaxHistoryMessages();
        System.out.println("使用消息数量限制: " + maxMessages + " (配置默认)");
        
        return limitMessages(messages, maxMessages);
    }
    
    /**
     * 限制消息数量，保留最新的N条消息（指定数量）
     * @param messages 原始消息列表
     * @param maxMessages 最大消息数量
     * @return 限制后的消息列表
     */
    private List<Message> limitMessages(List<Message> messages, int maxMessages) {
        if (messages == null || messages.isEmpty()) {
            return messages;
        }
        
        if (messages.size() <= maxMessages) {
            System.out.println("消息数量 (" + messages.size() + ") 未超过限制 (" + maxMessages + ")");
            return new ArrayList<>(messages);
        }
        
        // 保留最新的maxMessages条消息
        List<Message> limitedMessages = new ArrayList<>(messages.subList(messages.size() - maxMessages, messages.size()));
        
        System.out.println("消息数量限制: 原始 " + messages.size() + " 条 -> 保留最新 " + limitedMessages.size() + " 条");
        
        return limitedMessages;
    }


}
